YES 2.435 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ LR

mainModule List
  ((elemIndices :: Eq a => a  ->  [a ->  [Int]) :: Eq a => a  ->  [a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (\vv1 ->
case vv1 of
  (x,i)->  if p x then i : [] else []
  _-> []
) (zip xs (enumFrom 0))


module Maybe where
  import qualified List
import qualified Prelude



Lambda Reductions:
The following Lambda expression
\vv1
case vv1 of
 (x,i) → if p x then i : [] else []
 _ → []

is transformed to
findIndices0 p vv1 = 
case vv1 of
 (x,i) → if p x then i : [] else []
 _ → []

The following Lambda expression
\ab→(a,b)

is transformed to
zip0 a b = (a,b)



↳ HASKELL
  ↳ LR
HASKELL
      ↳ CR

mainModule List
  ((elemIndices :: Eq a => a  ->  [a ->  [Int]) :: Eq a => a  ->  [a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 
case vv1 of
  (x,i)->  if p x then i : [] else []
  _-> []


module Maybe where
  import qualified List
import qualified Prelude



Case Reductions:
The following Case expression
case vv1 of
 (x,i) → if p x then i : [] else []
 _ → []

is transformed to
findIndices00 p (x,i) = if p x then i : [] else []
findIndices00 p _ = []



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
HASKELL
          ↳ IFR

mainModule List
  ((elemIndices :: Eq a => a  ->  [a ->  [Int]) :: Eq a => a  ->  [a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,i if p x then i : [] else []
findIndices00 p _ []


module Maybe where
  import qualified List
import qualified Prelude



If Reductions:
The following If expression
if p x then i : [] else []

is transformed to
findIndices000 i True = i : []
findIndices000 i False = []



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
HASKELL
              ↳ BR

mainModule List
  ((elemIndices :: Eq a => a  ->  [a ->  [Int]) :: Eq a => a  ->  [a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,ifindIndices000 i (p x)
findIndices00 p _ []

  
findIndices000 i True i : []
findIndices000 i False []


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
HASKELL
                  ↳ COR

mainModule List
  ((elemIndices :: Eq a => a  ->  [a ->  [Int]) :: Eq a => a  ->  [a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,ifindIndices000 i (p x)
findIndices00 p vw []

  
findIndices000 i True i : []
findIndices000 i False []


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
HASKELL
                      ↳ NumRed

mainModule List
  ((elemIndices :: Eq a => a  ->  [a ->  [Int]) :: Eq a => a  ->  [a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom 0))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,ifindIndices000 i (p x)
findIndices00 p vw []

  
findIndices000 i True i : []
findIndices000 i False []


module Maybe where
  import qualified List
import qualified Prelude



Num Reduction: All numbers are transformed to thier corresponding representation with Pos, Neg, Succ and Zero.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
HASKELL
                          ↳ Narrow

mainModule List
  (elemIndices :: Eq a => a  ->  [a ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  elemIndices :: Eq a => a  ->  [a ->  [Int]
elemIndices x findIndices (== x)

  findIndices :: (a  ->  Bool ->  [a ->  [Int]
findIndices p xs concatMap (findIndices0 p) (zip xs (enumFrom (Pos Zero)))

  
findIndices0 p vv1 findIndices00 p vv1

  
findIndices00 p (x,ifindIndices000 i (p x)
findIndices00 p vw []

  
findIndices000 i True i : []
findIndices000 i False []


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primEqNat(Succ(yu1000), Succ(yu11000)) → new_primEqNat(yu1000, yu11000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primPlusNat(Succ(yu6400), Succ(yu1100000)) → new_primPlusNat(yu6400, yu1100000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primMulNat(Succ(yu10000), Succ(yu110000)) → new_primMulNat(yu10000, Succ(yu110000))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), app(ty_[], cc), bd, be) → new_esEs3(yu100, yu1100, cc)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), app(app(ty_Either, bf), bg), bd, be) → new_esEs0(yu100, yu1100, bf, bg)
new_esEs1(Just(yu100), Just(yu1100), app(app(app(ty_@3, he), hf), hg)) → new_esEs(yu100, yu1100, he, hf, hg)
new_esEs0(Right(yu100), Right(yu1100), gc, app(app(ty_@2, hb), hc)) → new_esEs2(yu100, yu1100, hb, hc)
new_esEs0(Left(yu100), Left(yu1100), app(ty_Maybe, fg), fc) → new_esEs1(yu100, yu1100, fg)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), cd, bd, app(app(ty_Either, eb), ec)) → new_esEs0(yu102, yu1102, eb, ec)
new_esEs3(:(yu100, yu101), :(yu1100, yu1101), app(ty_Maybe, bdg)) → new_esEs1(yu100, yu1100, bdg)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), cd, bd, app(ty_Maybe, ed)) → new_esEs1(yu102, yu1102, ed)
new_esEs3(:(yu100, yu101), :(yu1100, yu1101), app(ty_[], beb)) → new_esEs3(yu100, yu1100, beb)
new_esEs0(Right(yu100), Right(yu1100), gc, app(app(app(ty_@3, gd), ge), gf)) → new_esEs(yu100, yu1100, gd, ge, gf)
new_esEs2(@2(yu100, yu101), @2(yu1100, yu1101), bbh, app(ty_Maybe, bcf)) → new_esEs1(yu101, yu1101, bcf)
new_esEs2(@2(yu100, yu101), @2(yu1100, yu1101), bbh, app(app(ty_@2, bcg), bch)) → new_esEs2(yu101, yu1101, bcg, bch)
new_esEs2(@2(yu100, yu101), @2(yu1100, yu1101), app(ty_Maybe, bbd), bba) → new_esEs1(yu100, yu1100, bbd)
new_esEs1(Just(yu100), Just(yu1100), app(ty_[], bae)) → new_esEs3(yu100, yu1100, bae)
new_esEs2(@2(yu100, yu101), @2(yu1100, yu1101), app(app(ty_@2, bbe), bbf), bba) → new_esEs2(yu100, yu1100, bbe, bbf)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), app(app(app(ty_@3, ba), bb), bc), bd, be) → new_esEs(yu100, yu1100, ba, bb, bc)
new_esEs2(@2(yu100, yu101), @2(yu1100, yu1101), bbh, app(app(app(ty_@3, bca), bcb), bcc)) → new_esEs(yu101, yu1101, bca, bcb, bcc)
new_esEs2(@2(yu100, yu101), @2(yu1100, yu1101), bbh, app(app(ty_Either, bcd), bce)) → new_esEs0(yu101, yu1101, bcd, bce)
new_esEs0(Left(yu100), Left(yu1100), app(app(ty_Either, fd), ff), fc) → new_esEs0(yu100, yu1100, fd, ff)
new_esEs3(:(yu100, yu101), :(yu1100, yu1101), app(app(app(ty_@3, bdb), bdc), bdd)) → new_esEs(yu100, yu1100, bdb, bdc, bdd)
new_esEs0(Left(yu100), Left(yu1100), app(app(ty_@2, fh), ga), fc) → new_esEs2(yu100, yu1100, fh, ga)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), app(ty_Maybe, bh), bd, be) → new_esEs1(yu100, yu1100, bh)
new_esEs3(:(yu100, yu101), :(yu1100, yu1101), bec) → new_esEs3(yu101, yu1101, bec)
new_esEs0(Right(yu100), Right(yu1100), gc, app(app(ty_Either, gg), gh)) → new_esEs0(yu100, yu1100, gg, gh)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), app(app(ty_@2, ca), cb), bd, be) → new_esEs2(yu100, yu1100, ca, cb)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), cd, app(ty_Maybe, dc), be) → new_esEs1(yu101, yu1101, dc)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), cd, app(app(ty_Either, da), db), be) → new_esEs0(yu101, yu1101, da, db)
new_esEs2(@2(yu100, yu101), @2(yu1100, yu1101), app(app(app(ty_@3, baf), bag), bah), bba) → new_esEs(yu100, yu1100, baf, bag, bah)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), cd, app(app(ty_@2, dd), de), be) → new_esEs2(yu101, yu1101, dd, de)
new_esEs0(Left(yu100), Left(yu1100), app(ty_[], gb), fc) → new_esEs3(yu100, yu1100, gb)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), cd, app(app(app(ty_@3, ce), cf), cg), be) → new_esEs(yu101, yu1101, ce, cf, cg)
new_esEs2(@2(yu100, yu101), @2(yu1100, yu1101), app(ty_[], bbg), bba) → new_esEs3(yu100, yu1100, bbg)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), cd, bd, app(ty_[], eg)) → new_esEs3(yu102, yu1102, eg)
new_esEs1(Just(yu100), Just(yu1100), app(ty_Maybe, bab)) → new_esEs1(yu100, yu1100, bab)
new_esEs1(Just(yu100), Just(yu1100), app(app(ty_@2, bac), bad)) → new_esEs2(yu100, yu1100, bac, bad)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), cd, bd, app(app(ty_@2, ee), ef)) → new_esEs2(yu102, yu1102, ee, ef)
new_esEs0(Right(yu100), Right(yu1100), gc, app(ty_Maybe, ha)) → new_esEs1(yu100, yu1100, ha)
new_esEs2(@2(yu100, yu101), @2(yu1100, yu1101), bbh, app(ty_[], bda)) → new_esEs3(yu101, yu1101, bda)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), cd, app(ty_[], df), be) → new_esEs3(yu101, yu1101, df)
new_esEs2(@2(yu100, yu101), @2(yu1100, yu1101), app(app(ty_Either, bbb), bbc), bba) → new_esEs0(yu100, yu1100, bbb, bbc)
new_esEs0(Left(yu100), Left(yu1100), app(app(app(ty_@3, eh), fa), fb), fc) → new_esEs(yu100, yu1100, eh, fa, fb)
new_esEs3(:(yu100, yu101), :(yu1100, yu1101), app(app(ty_@2, bdh), bea)) → new_esEs2(yu100, yu1100, bdh, bea)
new_esEs3(:(yu100, yu101), :(yu1100, yu1101), app(app(ty_Either, bde), bdf)) → new_esEs0(yu100, yu1100, bde, bdf)
new_esEs1(Just(yu100), Just(yu1100), app(app(ty_Either, hh), baa)) → new_esEs0(yu100, yu1100, hh, baa)
new_esEs0(Right(yu100), Right(yu1100), gc, app(ty_[], hd)) → new_esEs3(yu100, yu1100, hd)
new_esEs(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), cd, bd, app(app(app(ty_@3, dg), dh), ea)) → new_esEs(yu102, yu1102, dg, dh, ea)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ CR
        ↳ HASKELL
          ↳ IFR
            ↳ HASKELL
              ↳ BR
                ↳ HASKELL
                  ↳ COR
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_psPs(yu40, False, yu42, :(yu430, yu431), yu44, ba) → new_psPs0(yu42, yu430, new_primPlusNat0(yu44, Zero), yu431, new_primPlusNat0(yu44, Zero), ba)
new_psPs1(yu42, :(yu430, yu431), yu44, ba) → new_psPs0(yu42, yu430, new_primPlusNat0(yu44, Zero), yu431, new_primPlusNat0(yu44, Zero), ba)
new_psPs(yu40, True, yu42, yu43, yu44, ba) → new_psPs1(yu42, yu43, yu44, ba)
new_psPs0(yu10, yu110, yu32, yu111, yu33, bb) → new_psPs(yu32, new_esEs4(yu10, yu110, bb), yu10, yu111, yu33, bb)

The TRS R consists of the following rules:

new_esEs23(yu102, yu1102, ty_Char) → new_esEs6(yu102, yu1102)
new_esEs8(yu100, yu1100, ty_Int) → new_esEs10(yu100, yu1100)
new_esEs15(Just(yu100), Just(yu1100), app(app(ty_Either, bdh), bea)) → new_esEs13(yu100, yu1100, bdh, bea)
new_primPlusNat1(Succ(yu6400), Succ(yu1100000)) → Succ(Succ(new_primPlusNat1(yu6400, yu1100000)))
new_esEs26(yu100, yu1100, app(app(app(ty_@3, beg), beh), bfa)) → new_esEs12(yu100, yu1100, beg, beh, bfa)
new_primEqInt(Pos(Succ(yu1000)), Neg(yu1100)) → False
new_primEqInt(Neg(Succ(yu1000)), Pos(yu1100)) → False
new_esEs25(yu101, yu1101, ty_Int) → new_esEs10(yu101, yu1101)
new_esEs23(yu102, yu1102, app(app(ty_@2, gb), gc)) → new_esEs18(yu102, yu1102, gb, gc)
new_esEs15(Just(yu100), Just(yu1100), ty_Bool) → new_esEs16(yu100, yu1100)
new_esEs4(yu10, yu110, ty_Int) → new_esEs10(yu10, yu110)
new_esEs26(yu100, yu1100, ty_Double) → new_esEs14(yu100, yu1100)
new_esEs11(Integer(yu100), Integer(yu1100)) → new_primEqInt(yu100, yu1100)
new_primEqInt(Pos(Zero), Neg(Succ(yu11000))) → False
new_primEqInt(Neg(Zero), Pos(Succ(yu11000))) → False
new_esEs26(yu100, yu1100, ty_Int) → new_esEs10(yu100, yu1100)
new_esEs15(Just(yu100), Just(yu1100), ty_Integer) → new_esEs11(yu100, yu1100)
new_esEs26(yu100, yu1100, ty_Integer) → new_esEs11(yu100, yu1100)
new_esEs13(Left(yu100), Left(yu1100), app(app(ty_Either, gh), ha), bh) → new_esEs13(yu100, yu1100, gh, ha)
new_esEs23(yu102, yu1102, app(app(ty_Either, ff), fg)) → new_esEs13(yu102, yu1102, ff, fg)
new_esEs15(Just(yu100), Just(yu1100), app(ty_Ratio, beb)) → new_esEs7(yu100, yu1100, beb)
new_esEs13(Left(yu100), Left(yu1100), app(ty_[], hf), bh) → new_esEs20(yu100, yu1100, hf)
new_esEs22(yu101, yu1101, app(ty_[], fa)) → new_esEs20(yu101, yu1101, fa)
new_esEs23(yu102, yu1102, ty_Float) → new_esEs17(yu102, yu1102)
new_esEs26(yu100, yu1100, ty_Float) → new_esEs17(yu100, yu1100)
new_primMulNat0(Zero, Zero) → Zero
new_esEs26(yu100, yu1100, app(ty_Maybe, bfe)) → new_esEs15(yu100, yu1100, bfe)
new_esEs4(yu10, yu110, ty_Ordering) → new_esEs19(yu10, yu110)
new_esEs21(yu100, yu1100, ty_Bool) → new_esEs16(yu100, yu1100)
new_esEs26(yu100, yu1100, app(ty_Ratio, bfd)) → new_esEs7(yu100, yu1100, bfd)
new_esEs23(yu102, yu1102, app(app(app(ty_@3, fb), fc), fd)) → new_esEs12(yu102, yu1102, fb, fc, fd)
new_esEs21(yu100, yu1100, app(ty_[], dg)) → new_esEs20(yu100, yu1100, dg)
new_primPlusNat0(Zero, yu110000) → Succ(yu110000)
new_esEs13(Right(yu100), Right(yu1100), bg, ty_Integer) → new_esEs11(yu100, yu1100)
new_esEs13(Left(yu100), Left(yu1100), ty_@0, bh) → new_esEs5(yu100, yu1100)
new_esEs24(yu100, yu1100, app(ty_Ratio, bbf)) → new_esEs7(yu100, yu1100, bbf)
new_esEs24(yu100, yu1100, ty_Ordering) → new_esEs19(yu100, yu1100)
new_sr(Neg(yu1000), Pos(yu11000)) → Neg(new_primMulNat0(yu1000, yu11000))
new_sr(Pos(yu1000), Neg(yu11000)) → Neg(new_primMulNat0(yu1000, yu11000))
new_esEs24(yu100, yu1100, ty_Float) → new_esEs17(yu100, yu1100)
new_esEs22(yu101, yu1101, ty_Integer) → new_esEs11(yu101, yu1101)
new_esEs15(Just(yu100), Just(yu1100), ty_Float) → new_esEs17(yu100, yu1100)
new_esEs15(Just(yu100), Just(yu1100), ty_@0) → new_esEs5(yu100, yu1100)
new_esEs24(yu100, yu1100, app(ty_Maybe, bbg)) → new_esEs15(yu100, yu1100, bbg)
new_esEs19(GT, LT) → False
new_esEs19(LT, GT) → False
new_esEs14(Double(yu100, yu101), Double(yu1100, yu1101)) → new_esEs10(new_sr(yu100, yu1100), new_sr(yu101, yu1101))
new_esEs25(yu101, yu1101, ty_Integer) → new_esEs11(yu101, yu1101)
new_esEs9(yu101, yu1101, ty_Int) → new_esEs10(yu101, yu1101)
new_esEs26(yu100, yu1100, app(app(ty_@2, bff), bfg)) → new_esEs18(yu100, yu1100, bff, bfg)
new_esEs4(yu10, yu110, app(ty_[], cd)) → new_esEs20(yu10, yu110, cd)
new_esEs25(yu101, yu1101, ty_Double) → new_esEs14(yu101, yu1101)
new_esEs24(yu100, yu1100, ty_Integer) → new_esEs11(yu100, yu1100)
new_esEs22(yu101, yu1101, app(app(ty_Either, ec), ed)) → new_esEs13(yu101, yu1101, ec, ed)
new_esEs4(yu10, yu110, ty_Float) → new_esEs17(yu10, yu110)
new_esEs22(yu101, yu1101, ty_Int) → new_esEs10(yu101, yu1101)
new_esEs23(yu102, yu1102, app(ty_Maybe, ga)) → new_esEs15(yu102, yu1102, ga)
new_esEs22(yu101, yu1101, ty_@0) → new_esEs5(yu101, yu1101)
new_esEs22(yu101, yu1101, app(app(ty_@2, eg), eh)) → new_esEs18(yu101, yu1101, eg, eh)
new_esEs23(yu102, yu1102, app(ty_[], gd)) → new_esEs20(yu102, yu1102, gd)
new_esEs26(yu100, yu1100, ty_@0) → new_esEs5(yu100, yu1100)
new_primEqNat0(Succ(yu1000), Zero) → False
new_primEqNat0(Zero, Succ(yu11000)) → False
new_esEs22(yu101, yu1101, ty_Float) → new_esEs17(yu101, yu1101)
new_esEs22(yu101, yu1101, ty_Char) → new_esEs6(yu101, yu1101)
new_esEs24(yu100, yu1100, app(app(app(ty_@3, bba), bbb), bbc)) → new_esEs12(yu100, yu1100, bba, bbb, bbc)
new_primEqInt(Pos(Zero), Pos(Zero)) → True
new_esEs22(yu101, yu1101, ty_Double) → new_esEs14(yu101, yu1101)
new_esEs19(GT, GT) → True
new_esEs18(@2(yu100, yu101), @2(yu1100, yu1101), cb, cc) → new_asAs(new_esEs24(yu100, yu1100, cb), new_esEs25(yu101, yu1101, cc))
new_esEs5(@0, @0) → True
new_esEs21(yu100, yu1100, app(app(app(ty_@3, ce), cf), cg)) → new_esEs12(yu100, yu1100, ce, cf, cg)
new_esEs22(yu101, yu1101, app(app(app(ty_@3, dh), ea), eb)) → new_esEs12(yu101, yu1101, dh, ea, eb)
new_esEs15(Nothing, Nothing, ca) → True
new_esEs15(Just(yu100), Just(yu1100), app(ty_[], bef)) → new_esEs20(yu100, yu1100, bef)
new_esEs4(yu10, yu110, ty_Integer) → new_esEs11(yu10, yu110)
new_esEs13(Right(yu100), Right(yu1100), bg, app(app(ty_@2, baf), bag)) → new_esEs18(yu100, yu1100, baf, bag)
new_esEs16(True, True) → True
new_esEs4(yu10, yu110, ty_Double) → new_esEs14(yu10, yu110)
new_esEs25(yu101, yu1101, ty_Ordering) → new_esEs19(yu101, yu1101)
new_esEs24(yu100, yu1100, ty_Bool) → new_esEs16(yu100, yu1100)
new_esEs20([], [], cd) → True
new_esEs13(Right(yu100), Right(yu1100), bg, ty_@0) → new_esEs5(yu100, yu1100)
new_esEs13(Right(yu100), Right(yu1100), bg, ty_Float) → new_esEs17(yu100, yu1100)
new_esEs4(yu10, yu110, app(app(ty_@2, cb), cc)) → new_esEs18(yu10, yu110, cb, cc)
new_esEs19(LT, LT) → True
new_esEs23(yu102, yu1102, ty_Double) → new_esEs14(yu102, yu1102)
new_esEs19(GT, EQ) → False
new_esEs19(EQ, GT) → False
new_esEs25(yu101, yu1101, ty_Bool) → new_esEs16(yu101, yu1101)
new_esEs15(Just(yu100), Just(yu1100), ty_Ordering) → new_esEs19(yu100, yu1100)
new_esEs25(yu101, yu1101, ty_@0) → new_esEs5(yu101, yu1101)
new_esEs13(Left(yu100), Left(yu1100), app(app(ty_@2, hd), he), bh) → new_esEs18(yu100, yu1100, hd, he)
new_esEs13(Left(yu100), Left(yu1100), ty_Bool, bh) → new_esEs16(yu100, yu1100)
new_esEs13(Right(yu100), Right(yu1100), bg, app(ty_[], bah)) → new_esEs20(yu100, yu1100, bah)
new_esEs22(yu101, yu1101, app(ty_Ratio, ee)) → new_esEs7(yu101, yu1101, ee)
new_sr(Neg(yu1000), Neg(yu11000)) → Pos(new_primMulNat0(yu1000, yu11000))
new_esEs24(yu100, yu1100, ty_Int) → new_esEs10(yu100, yu1100)
new_sr(Pos(yu1000), Pos(yu11000)) → Pos(new_primMulNat0(yu1000, yu11000))
new_asAs(False, yu63) → False
new_esEs25(yu101, yu1101, app(ty_[], bdd)) → new_esEs20(yu101, yu1101, bdd)
new_esEs13(Left(yu100), Left(yu1100), ty_Char, bh) → new_esEs6(yu100, yu1100)
new_primEqNat0(Zero, Zero) → True
new_esEs15(Just(yu100), Just(yu1100), ty_Int) → new_esEs10(yu100, yu1100)
new_primMulNat0(Succ(yu10000), Zero) → Zero
new_primMulNat0(Zero, Succ(yu110000)) → Zero
new_esEs20(:(yu100, yu101), :(yu1100, yu1101), cd) → new_asAs(new_esEs26(yu100, yu1100, cd), new_esEs20(yu101, yu1101, cd))
new_esEs12(@3(yu100, yu101, yu102), @3(yu1100, yu1101, yu1102), bd, be, bf) → new_asAs(new_esEs21(yu100, yu1100, bd), new_asAs(new_esEs22(yu101, yu1101, be), new_esEs23(yu102, yu1102, bf)))
new_esEs4(yu10, yu110, ty_Bool) → new_esEs16(yu10, yu110)
new_esEs13(Left(yu100), Left(yu1100), app(ty_Ratio, hb), bh) → new_esEs7(yu100, yu1100, hb)
new_esEs21(yu100, yu1100, app(app(ty_@2, de), df)) → new_esEs18(yu100, yu1100, de, df)
new_esEs13(Left(yu100), Left(yu1100), ty_Double, bh) → new_esEs14(yu100, yu1100)
new_esEs24(yu100, yu1100, ty_@0) → new_esEs5(yu100, yu1100)
new_esEs21(yu100, yu1100, app(ty_Maybe, dd)) → new_esEs15(yu100, yu1100, dd)
new_esEs13(Right(yu100), Right(yu1100), bg, app(ty_Maybe, bae)) → new_esEs15(yu100, yu1100, bae)
new_esEs26(yu100, yu1100, ty_Bool) → new_esEs16(yu100, yu1100)
new_esEs13(Left(yu100), Left(yu1100), app(app(app(ty_@3, ge), gf), gg), bh) → new_esEs12(yu100, yu1100, ge, gf, gg)
new_esEs4(yu10, yu110, app(app(app(ty_@3, bd), be), bf)) → new_esEs12(yu10, yu110, bd, be, bf)
new_esEs4(yu10, yu110, app(ty_Maybe, ca)) → new_esEs15(yu10, yu110, ca)
new_esEs21(yu100, yu1100, ty_@0) → new_esEs5(yu100, yu1100)
new_esEs26(yu100, yu1100, ty_Ordering) → new_esEs19(yu100, yu1100)
new_esEs25(yu101, yu1101, app(ty_Maybe, bda)) → new_esEs15(yu101, yu1101, bda)
new_esEs8(yu100, yu1100, ty_Integer) → new_esEs11(yu100, yu1100)
new_esEs4(yu10, yu110, ty_Char) → new_esEs6(yu10, yu110)
new_primPlusNat0(Succ(yu640), yu110000) → Succ(Succ(new_primPlusNat1(yu640, yu110000)))
new_esEs21(yu100, yu1100, ty_Ordering) → new_esEs19(yu100, yu1100)
new_esEs13(Right(yu100), Right(yu1100), bg, app(ty_Ratio, bad)) → new_esEs7(yu100, yu1100, bad)
new_esEs16(False, False) → True
new_esEs9(yu101, yu1101, ty_Integer) → new_esEs11(yu101, yu1101)
new_primEqInt(Neg(Succ(yu1000)), Neg(Succ(yu11000))) → new_primEqNat0(yu1000, yu11000)
new_esEs13(Right(yu100), Left(yu1100), bg, bh) → False
new_esEs13(Left(yu100), Right(yu1100), bg, bh) → False
new_esEs13(Right(yu100), Right(yu1100), bg, app(app(ty_Either, bab), bac)) → new_esEs13(yu100, yu1100, bab, bac)
new_esEs25(yu101, yu1101, app(app(ty_@2, bdb), bdc)) → new_esEs18(yu101, yu1101, bdb, bdc)
new_esEs24(yu100, yu1100, app(app(ty_@2, bbh), bca)) → new_esEs18(yu100, yu1100, bbh, bca)
new_esEs15(Just(yu100), Just(yu1100), app(ty_Maybe, bec)) → new_esEs15(yu100, yu1100, bec)
new_esEs19(EQ, EQ) → True
new_primPlusNat1(Zero, Succ(yu1100000)) → Succ(yu1100000)
new_primPlusNat1(Succ(yu6400), Zero) → Succ(yu6400)
new_esEs22(yu101, yu1101, ty_Ordering) → new_esEs19(yu101, yu1101)
new_esEs23(yu102, yu1102, app(ty_Ratio, fh)) → new_esEs7(yu102, yu1102, fh)
new_esEs16(True, False) → False
new_esEs16(False, True) → False
new_esEs6(Char(yu100), Char(yu1100)) → new_primEqNat0(yu100, yu1100)
new_esEs24(yu100, yu1100, ty_Char) → new_esEs6(yu100, yu1100)
new_esEs21(yu100, yu1100, ty_Double) → new_esEs14(yu100, yu1100)
new_esEs22(yu101, yu1101, app(ty_Maybe, ef)) → new_esEs15(yu101, yu1101, ef)
new_primEqInt(Neg(Zero), Neg(Zero)) → True
new_esEs25(yu101, yu1101, app(ty_Ratio, bch)) → new_esEs7(yu101, yu1101, bch)
new_esEs4(yu10, yu110, app(app(ty_Either, bg), bh)) → new_esEs13(yu10, yu110, bg, bh)
new_esEs23(yu102, yu1102, ty_Bool) → new_esEs16(yu102, yu1102)
new_esEs21(yu100, yu1100, ty_Integer) → new_esEs11(yu100, yu1100)
new_esEs13(Left(yu100), Left(yu1100), app(ty_Maybe, hc), bh) → new_esEs15(yu100, yu1100, hc)
new_esEs20([], :(yu1100, yu1101), cd) → False
new_esEs20(:(yu100, yu101), [], cd) → False
new_esEs13(Right(yu100), Right(yu1100), bg, ty_Char) → new_esEs6(yu100, yu1100)
new_primEqInt(Neg(Succ(yu1000)), Neg(Zero)) → False
new_primEqInt(Neg(Zero), Neg(Succ(yu11000))) → False
new_esEs24(yu100, yu1100, app(app(ty_Either, bbd), bbe)) → new_esEs13(yu100, yu1100, bbd, bbe)
new_esEs26(yu100, yu1100, ty_Char) → new_esEs6(yu100, yu1100)
new_esEs13(Left(yu100), Left(yu1100), ty_Ordering, bh) → new_esEs19(yu100, yu1100)
new_esEs13(Right(yu100), Right(yu1100), bg, ty_Ordering) → new_esEs19(yu100, yu1100)
new_esEs21(yu100, yu1100, app(app(ty_Either, da), db)) → new_esEs13(yu100, yu1100, da, db)
new_esEs23(yu102, yu1102, ty_Ordering) → new_esEs19(yu102, yu1102)
new_primPlusNat1(Zero, Zero) → Zero
new_esEs21(yu100, yu1100, ty_Float) → new_esEs17(yu100, yu1100)
new_asAs(True, yu63) → yu63
new_esEs13(Left(yu100), Left(yu1100), ty_Int, bh) → new_esEs10(yu100, yu1100)
new_esEs13(Right(yu100), Right(yu1100), bg, ty_Bool) → new_esEs16(yu100, yu1100)
new_primMulNat0(Succ(yu10000), Succ(yu110000)) → new_primPlusNat0(new_primMulNat0(yu10000, Succ(yu110000)), yu110000)
new_esEs15(Just(yu100), Nothing, ca) → False
new_esEs15(Nothing, Just(yu1100), ca) → False
new_esEs19(EQ, LT) → False
new_esEs19(LT, EQ) → False
new_esEs25(yu101, yu1101, app(app(ty_Either, bcf), bcg)) → new_esEs13(yu101, yu1101, bcf, bcg)
new_esEs25(yu101, yu1101, app(app(app(ty_@3, bcc), bcd), bce)) → new_esEs12(yu101, yu1101, bcc, bcd, bce)
new_esEs23(yu102, yu1102, ty_Int) → new_esEs10(yu102, yu1102)
new_primEqInt(Pos(Succ(yu1000)), Pos(Succ(yu11000))) → new_primEqNat0(yu1000, yu11000)
new_esEs13(Left(yu100), Left(yu1100), ty_Float, bh) → new_esEs17(yu100, yu1100)
new_esEs21(yu100, yu1100, ty_Int) → new_esEs10(yu100, yu1100)
new_esEs13(Left(yu100), Left(yu1100), ty_Integer, bh) → new_esEs11(yu100, yu1100)
new_esEs17(Float(yu100, yu101), Float(yu1100, yu1101)) → new_esEs10(new_sr(yu100, yu1100), new_sr(yu101, yu1101))
new_esEs15(Just(yu100), Just(yu1100), ty_Double) → new_esEs14(yu100, yu1100)
new_esEs13(Right(yu100), Right(yu1100), bg, app(app(app(ty_@3, hg), hh), baa)) → new_esEs12(yu100, yu1100, hg, hh, baa)
new_esEs15(Just(yu100), Just(yu1100), app(app(ty_@2, bed), bee)) → new_esEs18(yu100, yu1100, bed, bee)
new_esEs4(yu10, yu110, app(ty_Ratio, bc)) → new_esEs7(yu10, yu110, bc)
new_primEqNat0(Succ(yu1000), Succ(yu11000)) → new_primEqNat0(yu1000, yu11000)
new_esEs23(yu102, yu1102, ty_Integer) → new_esEs11(yu102, yu1102)
new_esEs24(yu100, yu1100, app(ty_[], bcb)) → new_esEs20(yu100, yu1100, bcb)
new_esEs13(Right(yu100), Right(yu1100), bg, ty_Int) → new_esEs10(yu100, yu1100)
new_esEs4(yu10, yu110, ty_@0) → new_esEs5(yu10, yu110)
new_esEs13(Right(yu100), Right(yu1100), bg, ty_Double) → new_esEs14(yu100, yu1100)
new_esEs7(:%(yu100, yu101), :%(yu1100, yu1101), bc) → new_asAs(new_esEs8(yu100, yu1100, bc), new_esEs9(yu101, yu1101, bc))
new_esEs22(yu101, yu1101, ty_Bool) → new_esEs16(yu101, yu1101)
new_esEs10(yu10, yu110) → new_primEqInt(yu10, yu110)
new_esEs25(yu101, yu1101, ty_Char) → new_esEs6(yu101, yu1101)
new_esEs21(yu100, yu1100, app(ty_Ratio, dc)) → new_esEs7(yu100, yu1100, dc)
new_esEs15(Just(yu100), Just(yu1100), ty_Char) → new_esEs6(yu100, yu1100)
new_primEqInt(Pos(Zero), Pos(Succ(yu11000))) → False
new_primEqInt(Pos(Succ(yu1000)), Pos(Zero)) → False
new_esEs26(yu100, yu1100, app(ty_[], bfh)) → new_esEs20(yu100, yu1100, bfh)
new_esEs26(yu100, yu1100, app(app(ty_Either, bfb), bfc)) → new_esEs13(yu100, yu1100, bfb, bfc)
new_primEqInt(Pos(Zero), Neg(Zero)) → True
new_primEqInt(Neg(Zero), Pos(Zero)) → True
new_esEs25(yu101, yu1101, ty_Float) → new_esEs17(yu101, yu1101)
new_esEs23(yu102, yu1102, ty_@0) → new_esEs5(yu102, yu1102)
new_esEs15(Just(yu100), Just(yu1100), app(app(app(ty_@3, bde), bdf), bdg)) → new_esEs12(yu100, yu1100, bde, bdf, bdg)
new_esEs24(yu100, yu1100, ty_Double) → new_esEs14(yu100, yu1100)
new_esEs21(yu100, yu1100, ty_Char) → new_esEs6(yu100, yu1100)

The set Q consists of the following terms:

new_esEs24(x0, x1, ty_Char)
new_esEs13(Right(x0), Right(x1), x2, ty_Float)
new_esEs22(x0, x1, ty_Ordering)
new_esEs15(Just(x0), Just(x1), ty_Ordering)
new_esEs24(x0, x1, ty_Integer)
new_esEs13(Right(x0), Right(x1), x2, app(ty_Ratio, x3))
new_esEs15(Just(x0), Just(x1), ty_Double)
new_esEs5(@0, @0)
new_esEs20([], [], x0)
new_primEqInt(Neg(Succ(x0)), Neg(Zero))
new_esEs4(x0, x1, ty_Bool)
new_primEqInt(Pos(Zero), Neg(Zero))
new_primEqInt(Neg(Zero), Pos(Zero))
new_esEs23(x0, x1, ty_Integer)
new_esEs18(@2(x0, x1), @2(x2, x3), x4, x5)
new_esEs6(Char(x0), Char(x1))
new_esEs25(x0, x1, ty_Float)
new_esEs13(Right(x0), Right(x1), x2, ty_Char)
new_esEs26(x0, x1, ty_@0)
new_esEs21(x0, x1, ty_Bool)
new_esEs15(Nothing, Just(x0), x1)
new_esEs4(x0, x1, app(app(ty_Either, x2), x3))
new_esEs24(x0, x1, app(app(ty_@2, x2), x3))
new_esEs15(Just(x0), Nothing, x1)
new_esEs13(Left(x0), Left(x1), app(ty_[], x2), x3)
new_esEs4(x0, x1, ty_Int)
new_esEs26(x0, x1, ty_Char)
new_esEs11(Integer(x0), Integer(x1))
new_primEqInt(Neg(Zero), Neg(Zero))
new_esEs21(x0, x1, ty_@0)
new_esEs22(x0, x1, ty_Float)
new_esEs4(x0, x1, ty_Float)
new_esEs13(Right(x0), Right(x1), x2, ty_Integer)
new_esEs15(Just(x0), Just(x1), ty_Int)
new_esEs7(:%(x0, x1), :%(x2, x3), x4)
new_esEs24(x0, x1, ty_Double)
new_esEs26(x0, x1, app(app(ty_@2, x2), x3))
new_esEs21(x0, x1, app(ty_Ratio, x2))
new_esEs25(x0, x1, ty_Integer)
new_asAs(True, x0)
new_esEs20([], :(x0, x1), x2)
new_esEs21(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs24(x0, x1, app(ty_Ratio, x2))
new_esEs20(:(x0, x1), :(x2, x3), x4)
new_esEs22(x0, x1, app(app(ty_@2, x2), x3))
new_esEs25(x0, x1, ty_Double)
new_primEqNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), x1)
new_esEs23(x0, x1, app(app(ty_Either, x2), x3))
new_esEs26(x0, x1, app(ty_Maybe, x2))
new_primEqInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_esEs15(Just(x0), Just(x1), app(app(ty_Either, x2), x3))
new_esEs24(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primEqNat0(Succ(x0), Succ(x1))
new_esEs25(x0, x1, ty_Int)
new_esEs23(x0, x1, ty_@0)
new_esEs4(x0, x1, ty_Ordering)
new_esEs21(x0, x1, ty_Integer)
new_esEs13(Right(x0), Right(x1), x2, ty_Int)
new_esEs26(x0, x1, ty_Double)
new_esEs24(x0, x1, ty_Ordering)
new_esEs25(x0, x1, app(ty_[], x2))
new_esEs13(Left(x0), Left(x1), ty_Float, x2)
new_esEs15(Just(x0), Just(x1), ty_Char)
new_esEs8(x0, x1, ty_Integer)
new_esEs23(x0, x1, app(ty_[], x2))
new_esEs22(x0, x1, app(ty_Ratio, x2))
new_esEs13(Left(x0), Left(x1), ty_Double, x2)
new_esEs10(x0, x1)
new_esEs23(x0, x1, ty_Char)
new_esEs16(False, True)
new_esEs16(True, False)
new_esEs25(x0, x1, app(app(ty_Either, x2), x3))
new_esEs26(x0, x1, ty_Ordering)
new_esEs15(Just(x0), Just(x1), app(app(ty_@2, x2), x3))
new_esEs24(x0, x1, ty_Bool)
new_esEs15(Nothing, Nothing, x0)
new_esEs25(x0, x1, ty_Bool)
new_sr(Pos(x0), Neg(x1))
new_sr(Neg(x0), Pos(x1))
new_esEs26(x0, x1, ty_Integer)
new_esEs21(x0, x1, app(ty_Maybe, x2))
new_esEs13(Left(x0), Left(x1), app(app(app(ty_@3, x2), x3), x4), x5)
new_esEs13(Left(x0), Left(x1), ty_Integer, x2)
new_esEs16(True, True)
new_esEs15(Just(x0), Just(x1), ty_@0)
new_esEs26(x0, x1, ty_Float)
new_esEs4(x0, x1, app(ty_Ratio, x2))
new_primEqNat0(Zero, Succ(x0))
new_esEs4(x0, x1, app(ty_[], x2))
new_esEs13(Right(x0), Right(x1), x2, app(ty_[], x3))
new_esEs14(Double(x0, x1), Double(x2, x3))
new_esEs26(x0, x1, app(app(ty_Either, x2), x3))
new_esEs13(Left(x0), Left(x1), ty_Ordering, x2)
new_esEs15(Just(x0), Just(x1), ty_Integer)
new_esEs22(x0, x1, ty_Integer)
new_esEs12(@3(x0, x1, x2), @3(x3, x4, x5), x6, x7, x8)
new_primEqNat0(Zero, Zero)
new_primPlusNat1(Succ(x0), Succ(x1))
new_primEqInt(Pos(Succ(x0)), Pos(Zero))
new_esEs24(x0, x1, ty_Int)
new_esEs13(Left(x0), Left(x1), ty_Char, x2)
new_esEs19(GT, GT)
new_esEs26(x0, x1, app(ty_Ratio, x2))
new_esEs13(Left(x0), Left(x1), ty_@0, x2)
new_esEs21(x0, x1, app(ty_[], x2))
new_esEs13(Right(x0), Right(x1), x2, ty_Double)
new_esEs9(x0, x1, ty_Int)
new_sr(Pos(x0), Pos(x1))
new_esEs13(Right(x0), Right(x1), x2, app(app(ty_@2, x3), x4))
new_esEs22(x0, x1, ty_Double)
new_esEs25(x0, x1, app(ty_Ratio, x2))
new_esEs13(Right(x0), Right(x1), x2, app(app(app(ty_@3, x3), x4), x5))
new_esEs21(x0, x1, app(app(ty_Either, x2), x3))
new_esEs13(Left(x0), Left(x1), app(app(ty_@2, x2), x3), x4)
new_esEs21(x0, x1, ty_Char)
new_esEs15(Just(x0), Just(x1), ty_Float)
new_primMulNat0(Zero, Zero)
new_esEs16(False, False)
new_esEs13(Left(x0), Left(x1), app(ty_Ratio, x2), x3)
new_esEs19(EQ, EQ)
new_esEs15(Just(x0), Just(x1), app(ty_Ratio, x2))
new_esEs13(Left(x0), Left(x1), ty_Bool, x2)
new_esEs22(x0, x1, app(ty_Maybe, x2))
new_primEqInt(Pos(Zero), Pos(Succ(x0)))
new_esEs22(x0, x1, app(ty_[], x2))
new_asAs(False, x0)
new_esEs22(x0, x1, ty_Bool)
new_sr(Neg(x0), Neg(x1))
new_esEs22(x0, x1, ty_Char)
new_primPlusNat1(Succ(x0), Zero)
new_esEs19(LT, EQ)
new_esEs19(EQ, LT)
new_esEs20(:(x0, x1), [], x2)
new_esEs23(x0, x1, ty_Double)
new_esEs22(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs25(x0, x1, app(app(ty_@2, x2), x3))
new_esEs23(x0, x1, app(ty_Ratio, x2))
new_esEs23(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs19(LT, GT)
new_esEs19(GT, LT)
new_esEs24(x0, x1, app(app(ty_Either, x2), x3))
new_esEs25(x0, x1, app(ty_Maybe, x2))
new_esEs23(x0, x1, app(ty_Maybe, x2))
new_esEs19(LT, LT)
new_esEs25(x0, x1, ty_Ordering)
new_esEs19(GT, EQ)
new_esEs19(EQ, GT)
new_esEs4(x0, x1, app(app(ty_@2, x2), x3))
new_esEs24(x0, x1, ty_Float)
new_primMulNat0(Succ(x0), Succ(x1))
new_esEs22(x0, x1, ty_Int)
new_esEs21(x0, x1, ty_Float)
new_esEs25(x0, x1, ty_Char)
new_esEs4(x0, x1, ty_Double)
new_esEs13(Left(x0), Left(x1), app(ty_Maybe, x2), x3)
new_esEs4(x0, x1, ty_Integer)
new_esEs13(Right(x0), Right(x1), x2, app(app(ty_Either, x3), x4))
new_esEs25(x0, x1, ty_@0)
new_esEs4(x0, x1, ty_Char)
new_esEs23(x0, x1, ty_Int)
new_esEs23(x0, x1, app(app(ty_@2, x2), x3))
new_esEs24(x0, x1, ty_@0)
new_esEs9(x0, x1, ty_Integer)
new_esEs23(x0, x1, ty_Bool)
new_esEs4(x0, x1, app(ty_Maybe, x2))
new_esEs23(x0, x1, ty_Ordering)
new_esEs25(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs4(x0, x1, ty_@0)
new_esEs15(Just(x0), Just(x1), app(app(app(ty_@3, x2), x3), x4))
new_primPlusNat0(Zero, x0)
new_esEs13(Left(x0), Right(x1), x2, x3)
new_esEs13(Right(x0), Left(x1), x2, x3)
new_esEs21(x0, x1, ty_Double)
new_esEs21(x0, x1, app(app(ty_@2, x2), x3))
new_esEs21(x0, x1, ty_Ordering)
new_esEs15(Just(x0), Just(x1), app(ty_Maybe, x2))
new_esEs17(Float(x0, x1), Float(x2, x3))
new_esEs13(Right(x0), Right(x1), x2, ty_@0)
new_esEs15(Just(x0), Just(x1), app(ty_[], x2))
new_esEs24(x0, x1, app(ty_[], x2))
new_esEs8(x0, x1, ty_Int)
new_esEs13(Right(x0), Right(x1), x2, ty_Ordering)
new_primPlusNat1(Zero, Zero)
new_esEs26(x0, x1, app(ty_[], x2))
new_esEs4(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primEqInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_esEs22(x0, x1, ty_@0)
new_esEs23(x0, x1, ty_Float)
new_esEs13(Left(x0), Left(x1), app(app(ty_Either, x2), x3), x4)
new_primPlusNat1(Zero, Succ(x0))
new_esEs26(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs13(Left(x0), Left(x1), ty_Int, x2)
new_primMulNat0(Zero, Succ(x0))
new_primEqInt(Pos(Zero), Pos(Zero))
new_primEqInt(Neg(Zero), Neg(Succ(x0)))
new_esEs13(Right(x0), Right(x1), x2, ty_Bool)
new_primEqInt(Pos(Zero), Neg(Succ(x0)))
new_primEqInt(Neg(Zero), Pos(Succ(x0)))
new_primMulNat0(Succ(x0), Zero)
new_esEs22(x0, x1, app(app(ty_Either, x2), x3))
new_esEs24(x0, x1, app(ty_Maybe, x2))
new_esEs26(x0, x1, ty_Int)
new_esEs13(Right(x0), Right(x1), x2, app(ty_Maybe, x3))
new_primEqInt(Neg(Succ(x0)), Pos(x1))
new_primEqInt(Pos(Succ(x0)), Neg(x1))
new_esEs15(Just(x0), Just(x1), ty_Bool)
new_esEs26(x0, x1, ty_Bool)
new_esEs21(x0, x1, ty_Int)

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: